北京大学暑期课程实验部分编程基础内容介绍

Author：Hongyu Xiao

Graduate Student
University of Illinois at Urbana–Champaign
August, 2020

Modified based on https://github.com/inducer/languages-and-codegen-tutorial
and http://c.biancheng.net/view/2010.html

如果有遇到问题的话

请联系我！

邮箱是：hongyu.xiao@hotmail.com

标题开头为： PEK_Summer_Question

例如 PEK_Summer_Question anaconda无法下载

Python 部分学习预期

* 了解基本的python数据类型查看

* 学会如何创建和查看一个python变量的值和类型

* 了解python的indexing/slicing规则

* 了解Python基本的for/if/else/while等控制结构

* 了解Python的定义函数

* (Optional)Python中的object和inheritance

Python简介目录

1. Types

2. Names and Values

3. Indexing

4. Control flow

5. Functions

6. Objects

1. Python Introduction: Types

Python的变量采用动态形式，并不需要在一开始指定变量的type

先来看一下简单的python表达式

In [1]:
#clear
3*2
Out[1]:
6
In [ ]:
查看表达式或者变量的type，使用函数type（）
In [2]:
#clear
type(5+3*2)
Out[2]:
int
In [3]:
#clear
5+3.5*2
Out[3]:
12.0
In [4]:
#clear
type(5+3.5*2)
Out[4]:
float

Strings 一般用单引号或者双引号括起来

In [5]:
#clear
"你好"
Out[5]:
'你好'

string 还可以进行加法和乘法运算

In [9]:
#clear
3 * '哔哩 ' + "北大"
Out[9]:
'哔哩 哔哩 哔哩 北大'

List都是用方括号括起来，用comma进行区隔其中每一个值

In [11]:
#clear
[6, 6, 6]
Out[11]:
[6, 6, 6]

并且对于list中的每一个元素，他们不需要有同样的type

In [12]:
["奥里给", 666, [.1,.2,.3]]
Out[12]:
['奥里给', 666, [0.1, 0.2, 0.3]]

并且对于list，还是可以使用乘法和加法

In [14]:
["奥",'里','给'] * 4 + [6, 6, 6]
Out[14]:
['奥', '里', '给', '奥', '里', '给', '奥', '里', '给', '奥', '里', '给', 6, 6, 6]
In [15]:
[1,2,3] * 4 + [5, 5, 5]
Out[15]:
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, 5, 5]

如果想要进行数学意义上的数组运算的乘法和加法的话，需要借助一个module叫做numpy

In [3]:
#clear

import numpy as np

np.array([1,2,3]) * 4 + np.array([5, 5, 5])
Out[3]:
array([ 9, 13, 17])

numpy 是我们进行科学计算的非常常用的一个package！

2. Python Introduction: Names and Values

定义一个变量，并且使用它

In [5]:
#clear
VariableBaseLine = 3*2 + 5
In [6]:
#clear
VariableBaseLine
Out[6]:
11
In [8]:
#clear
VariableBaseLine = "哔哩"*3
In [9]:
#clear
VariableBaseLine
Out[9]:
'哔哩哔哩哔哩'

我们并不需要声明变量的类型，并且在python中，我们是可以直接改变变量类型的！

变量类型可以随时改变，并不代表没有类型。

In [10]:
#clear
type(VariableBaseLine)
Out[10]:
str

Python 的变量有点像指针

举个例子

In [12]:
Variable_List = [1,2,3]
In [14]:
Variable_List_Second = Variable_List
In [15]:
#clear
Variable_List_Second.append(4)
In [16]:
#clear
Variable_List_Second
Out[16]:
[1, 2, 3, 4]
In [17]:
#clear
Variable_List
Out[17]:
[1, 2, 3, 4]

你会发现，随着Variable_List_Second变化，原变量也发生了变化！

你可以用id（）去查看变量的地址

In [18]:
#clear

print(id(Variable_List), id(Variable_List_Second))

1439216159488 1439216159488

这俩地址是一模一样的！

我们来测试一下变量的是否是同一个

In [19]:
#clear
Variable_List is Variable_List_Second
Out[19]:
True

这个地方一定要多加注意，这个要比值相等要更高一级。

In [20]:
Variable_List = [1,2,3]
Variable_List_Second = [1,2,3]
print("IS   ", Variable_List is Variable_List_Second)
print("EQUAL", Variable_List == Variable_List_Second)

IS    False
EQUAL True

看了上面的例子，我们来推测一下下面的这个结果

In [22]:
#clear
Variable_List = [1,2,3]
Variable_List_Second = Variable_List
Variable_List = Variable_List + [4]
print(Variable_List_Second)

[1, 2, 3]
In [23]:
Variable_List is Variable_List_Second
Out[23]:
False

为什么会出现这个结果？

  • 请思考以下 在这里面 + 和 .append() 区别在什么地方

我们来查看一下下面的例子，列出来各个变量的储存地址

In [29]:
#clear
Variable_List = [1,2,3]
Variable_List_Second = Variable_List


print(id(Variable_List), id(Variable_List_Second))
print ("********************")

Variable_List = Variable_List + [4]
print(Variable_List_Second)

print(id(Variable_List), id(Variable_List_Second))
print ("********************")

1439217317568 1439217317568
********************
[1, 2, 3]
1439234789504 1439217317568
********************
Out[29]:
list

你会发现因为动态类型，所以list内容是可以被更改的！

这也是为什么在python里面有一个类型叫做tuple，tuple就是无法更改元素的list！

In [30]:
Variable_List = [1,2,3]
type(Variable_List)
Out[30]:
list
In [31]:
#clear
Variable_List = (1,2,3)

type(Variable_List)
Out[31]:
tuple

如果你试图去改变tuple的话....

In [32]:
#clear
Variable_List[2] = 0

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-32-619f7f765ab7> in <module>
      1 #clear
----> 2 Variable_List[2] = 0

TypeError: 'tuple' object does not support item assignment

你就会得到一个错误信息了

如果你有一个元素，但是你想创建一个tuple该怎么办？

In [33]:
#clear
Variable_List = (3,)

type(Variable_List)
Out[33]:
tuple

3. Python Introduction: Indexing

我们常用的range函数可以直接创建一个数字的list

In [35]:
#clear
list(range(10, 20))
Out[35]:
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Python的index是从0开始的！！

Python的index是从0开始的！！

Python的index是从0开始的！！

In [36]:
Variable_List = list(range(10, 20))
type(Variable_List)
Out[36]:
list
In [37]:
#clear
Variable_List[0]
Out[37]:
10
In [39]:
#clear
Variable_List[1]
Out[39]:
11
In [41]:
#clear
Variable_List[5]
Out[41]:
15

你还可以使用负数

In [42]:
#clear
Variable_List[-1]
Out[42]:
19
In [43]:
#clear
Variable_List[-2]
Out[43]:
18

你还可以抽取list其中的一部分

In [44]:
#clear
Variable_List[3:7]
Out[44]:
[13, 14, 15, 16]

对于这种截取，并不一定要指定开头和结尾

In [45]:
#clear
Variable_List[3:]
Out[45]:
[13, 14, 15, 16, 17, 18, 19]
In [46]:
#clear
Variable_List[:7]
Out[46]:
[10, 11, 12, 13, 14, 15, 16]
In [48]:
print(Variable_List[:3])
print(Variable_List[3])

[10, 11, 12]
13

Python的index是包含前面，不包含后面的！

不仅如此，slicing在python中可以应用到任何的类型里面! (list, tuple, str, numpy array)

In [51]:
Variable_Title = "北京大学暑期学校"
Variable_Title[-3:]
Out[51]:
'期学校'

4. Python Introduction: Control flow

python中的for循环会遍历list

In [52]:
#clear
for i in range(10):

    print(i)

0
1
2
3
4
5
6
7
8
9

在使用for循环的时候有两点需要注意

1. 要在for语句后面加上：

2. Python使用空格来控制结构的！！

if/else 的基本语法也类似

例子如下

In [53]:
for i in range(10):
    if i % 3 == 0:
        print("{0} 可以被3整除 ".format(i))
    else:
        print("{0} 不可以被3整除".format(i))

0 可以被3整除 
1 不可以被3整除
2 不可以被3整除
3 可以被3整除 
4 不可以被3整除
5 不可以被3整除
6 可以被3整除 
7 不可以被3整除
8 不可以被3整除
9 可以被3整除

类似的还有 while 循环

例子如下

In [56]:
i = 0
while True:
    i += 1
    if i**3 + i**2 + i + 1 == 3616:
        break

print("答案:", i)

答案: 15

创建list的时候，有时候代码会有点长

比如我们想要创建一个list包含50以内能被7整除的整数的平方

In [57]:
#clear
mylist = []

for i in range(50):

    if i % 7 == 0:

        mylist.append(i**2)
In [58]:
mylist
Out[58]:
[0, 49, 196, 441, 784, 1225, 1764, 2401]

Python 支持list缩略创建

具体语法如下

In [60]:
#clear
mylist = [i**2 for i in range(50) if i % 7 == 0]
In [61]:
mylist
Out[61]:
[0, 49, 196, 441, 784, 1225, 1764, 2401]

5. Python Introduction: Functions

我们一般使用function减少我们重复使用的部分代码

下面以创建print_greeting()为例进行说明

In [65]:
def print_greeting():
    print("哎呀妈呀，你最近咋样？")
    print("好久不见啊")

然后使用这个函数

In [66]:
print_greeting()

哎呀妈呀，你最近咋样？
好久不见啊

现在这个写法没有输入输出，我们可以让这个函数更有人情味一点。

In [68]:
#clear
def print_greeting(name="老哥"):

    print("哎呀妈呀, {0}, 你最近咋样?".format(name))

    print("好久不见啊")
In [72]:
print_greeting("蔡徐坤")

print()

print_greeting()

哎呀妈呀, 蔡徐坤, 你最近咋样?
好久不见啊

哎呀妈呀, 老哥, 你最近咋样?
好久不见啊

这样看起来是不是就更亲近一点了？ ：）

function的参数可以作为变量

比如下面个例子

In [73]:
def my_func(my_list):
    my_list.append(5)
    
List_Inital = [1,2,3]
my_func(List_Inital)
print(List_Inital)

[1, 2, 3, 5]

不仅如此，还可以function还可以返回一定的值

比如下面的例子

In [74]:
#clear
def my_func_2(my_list):

    return my_list + [5]
In [75]:
List_Inital = [1,2,3]
List_Inital_2 = my_func_2(List_Inital)
print(List_Inital)
print(List_Inital_2)

[1, 2, 3]
[1, 2, 3, 5]

将大量的重复模块进行函数化是我们在python编程中常用的方法之一

6. Python Introduction: Objects

在python中，所有的都是Object

定义一个Object非常容易：

In [1]:
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        
    def fire(self):
        self.salary = 0

  • 在class里面的function称为'methods'

  • 他们一般有一个明确的self parameter, 我们可以使用这个self parameter去构建object

  • init 就是这个基本构建

    • Objects通过呼叫这个type的方式被创建，
    • 在这个呼叫type的过程中，传递的argument就进入到了基本构建，完成了这个object。

这么说起来可能有些模糊

下面给出例子

In [2]:
老张 = Employee("老张", 100000)

老张.name
Out[2]:
'老张'

我们建立一个一个object，老张

老张有俩基本信息，姓名和工资

In [3]:
#clear
老张.salary
Out[3]:
100000

老张被建立的时候，这个里头还有一个method叫做fire

下面我们开除老张

In [4]:
#clear
老张.fire()
In [5]:
#clear
老张.salary
Out[5]:
0

可以看到，老张的工资成了0。

Inheritance 继承

Type可以从其他的Type去继承属性

In [6]:
class Boss(Employee):
    def __init__(self, name, salary, supervises):
        super(Boss, self).__init__(name, salary)
        
        self.supervises = supervises
        
    def fire(self):
        for s in self.supervises:
            s.fire()
            
        super(Boss, self).fire()
In [7]:
老张 = Employee("老张", 100000)
老王 = Employee("老王", 100000)
李老板 = Boss("老李", 150000, [老张, 老王])

李老板.salary
Out[7]:
150000

如果我们开除老李呢？

In [8]:
#clear
李老板.fire()
In [9]:
#clear
老张.salary
Out[9]:
0

：）